package com.example.waterdispenserm2.vmc;

import java.io.Serializable;
import java.util.Arrays;

public class DataParser {
    // 解析下位机返回数据
    public static DeviceData parse(byte[] data) {
        if (data.length < 3) {
            return null; // 数据长度不足
        }

        byte header1 = data[0];
        byte header2 = data[1];

        // 验证包头
        if (header1 != (byte) 0xAA) {
            return null;
        }

        DeviceData result = new DeviceData();

        // 根据包头2判断数据类型
        switch (header2) {
            case (byte) 0x55: // 实时状态数据
                parseRealtimeData(data, result);
                break;

            case (byte) 0x66: // IO状态数据
                parseIOStatus(data, result);
                break;

            case (byte) 0x11: // 累计数据
                parseSummaryData(data, result);
                break;

            case (byte) 0x77: // 错误信息
                parseErrorData(data, result);
                break;

            case (byte) 0xEE: // 指令响应
                parseCommandResponse(data, result);
                break;
        }
        return result;
    }

    /**
     * 解析实时状态数据
     * @param data 原始数据
     * @param result 解析结果对象
     */
    private static void parseRealtimeData(byte[] data, DeviceData result) {
        if (data.length < 16) return;

        // 实时温度 (第4字节)
        result.currentTemp = data[3] & 0xFF;

        // 实时水量 (第5-6字节, 高位在前)
        result.currentVolume = ((data[4] & 0xFF) << 8) | (data[5] & 0xFF);

        // IO状态 (第7-13字节)
        result.input1 = (data[6] & 0x01) == 0x01; // IN1: bit0
        result.input2 = (data[7] & 0x01) == 0x01; // IN2: bit0

        // 输出状态
        result.output1 = (data[8] & 0x01) == 0x01; // OUT1: bit0
        result.output2 = (data[9] & 0x01) == 0x01; // OUT2: bit0

        // 输入3/4 (第11字节)
        result.input3 = (data[10] & 0x01) == 0x01; // IN3: bit0
        result.input4 = (data[10] & 0x04) == 0x04; // IN4: bit2

        // 输出3/4
        result.output3 = (data[11] & 0x01) == 0x01; // OUT3: bit0
        result.output4 = (data[12] & 0x01) == 0x01; // OUT4: bit0

        result.dataType = DeviceData.DATA_TYPE_REALTIME;
    }

    /**
     * 解析IO状态数据
     * @param data 原始数据
     * @param result 解析结果对象
     */
    private static void parseIOStatus(byte[] data, DeviceData result) {
        if (data.length < 16) return;

        // 输出状态
        result.output1 = (data[2] & 0x01) == 0x01; // OUT1: bit0
        result.output2 = (data[6] & 0x01) == 0x01; // OUT2: bit0
        result.output3 = (data[9] & 0x01) == 0x01; // OUT3: bit0
        result.output4 = (data[10] & 0x01) == 0x01; // OUT4: bit0

        // 输入状态
        result.input1 = (data[3] & 0x01) == 0x01; // IN1: bit0
        result.input2 = (data[4] & 0x01) == 0x01; // IN2: bit0
        result.input3 = (data[7] & 0x01) == 0x01; // IN3: bit0
        result.input4 = (data[8] & 0x01) == 0x01; // IN4: bit0

        result.dataType = DeviceData.DATA_TYPE_IO_STATUS;
    }

    /**
     * 解析累计数据
     * @param data 原始数据
     * @param result 解析结果对象
     */
    private static void parseSummaryData(byte[] data, DeviceData result) {
        if (data.length < 16) return;

        // 累计出水量 (3-6字节, 低位在前)
        result.totalWater = ((data[5] & 0xFF) << 24) |
                ((data[4] & 0xFF) << 16) |
                ((data[3] & 0xFF) << 8)  |
                (data[2] & 0xFF);

        // 累计加热次数 (7-10字节)
        result.heatingCount = ((data[9] & 0xFF) << 24) |
                ((data[8] & 0xFF) << 16) |
                ((data[7] & 0xFF) << 8)  |
                (data[6] & 0xFF);

        // 累计工作时间 (11-13字节)
        result.workingTime = ((data[12] & 0xFF) << 16) |
                ((data[11] & 0xFF) << 8)  |
                (data[10] & 0xFF);

        result.dataType = DeviceData.DATA_TYPE_SUMMARY;
    }

    /**
     * 解析错误信息
     * @param data 原始数据
     * @param result 解析结果对象
     */
    private static void parseErrorData(byte[] data, DeviceData result) {
        if (data.length < 16) return;

        result.currentError = data[2] & 0xFF; // 当前错误码
        // 历史错误 (4-12字节)
        result.historyErrors = Arrays.copyOfRange(data, 3, 12);

        result.dataType = DeviceData.DATA_TYPE_ERROR;
    }

    /**
     * 解析指令响应
     * @param data 原始数据
     * @param result 解析结果对象
     */
    private static void parseCommandResponse(byte[] data, DeviceData result) {
        if (data.length < 16) return;

        result.commandAck = data[2] & 0xFF; // 指令响应类型
        result.dataType = DeviceData.DATA_TYPE_COMMAND_RESPONSE;
    }

    /**
     * 设备数据封装类
     * 包含所有可能的数据字段
     */
    public static class DeviceData implements Serializable {
        public static final int DATA_TYPE_REALTIME = 1;         // 实时数据
        public static final int DATA_TYPE_IO_STATUS = 2;        // IO状态
        public static final int DATA_TYPE_SUMMARY = 3;           // 累计数据
        public static final int DATA_TYPE_ERROR = 4;             // 错误信息
        public static final int DATA_TYPE_COMMAND_RESPONSE = 5;  // 指令响应

        public int dataType = 0;             // 数据类型

        // 实时数据
        public int currentTemp = 0;           // 当前温度(℃)
        public int currentVolume = 0;         // 当前水量(ml)

        // IO状态
        public boolean input1 = false;        // 输入1状态
        public boolean input2 = false;        // 输入2状态
        public boolean input3 = false;        // 输入3状态(净水版)
        public boolean input4 = false;        // 输入4状态(净水版)
        public boolean output1 = false;       // UV灯状态
        public boolean output2 = false;       // 进水阀状态
        public boolean output3 = false;       // 冲洗阀状态(净水版)
        public boolean output4 = false;       // 增压泵状态(净水版)

        // 累计数据
        public long totalWater = 0;           // 累计出水量(ml)
        public long heatingCount = 0;         // 累计加热次数
        public long workingTime = 0;          // 累计工作时间(秒)

        // 错误信息
        public int currentError = 0;          // 当前错误码
        public byte[] historyErrors;          // 历史错误记录

        // 指令响应
        public int commandAck = 0;            // 指令响应类型
    }
}